home *** CD-ROM | disk | FTP | other *** search
/ SuperHack / SuperHack CD.bin / CODING / DELPHI / LEDIT108.ZIP / LEMFC / LEMFC.CPP < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-10  |  17.7 KB  |  776 lines
  1. // =========================================================================
  2. //       LEdit wrapper for Microsoft MFC 2.5 & 3.0 (16-/32-bit Windows)
  3. //       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  4. //       Version 1.08
  5. //       (c) 1996-1996 Andrey B. Yastrebov
  6. //       Nobody can modify this file without written permission of author
  7. //
  8. //       Limitations of current version:
  9. //       Summary length of all editing files: min(ca 60M,your memory)
  10. //       Maximum line length: 8K
  11. //
  12. //       Windows      is a trademark of Microsoft corp.
  13. //
  14. //       If you have some questions please contact:  xor@hawk.usr.pu.ru
  15. // =========================================================================
  16. #include "stdafx.h"
  17. #include "lemfc.h"
  18.  
  19. #ifdef _DEBUG
  20. #undef THIS_FILE
  21. static char BASED_CODE THIS_FILE[] = __FILE__;
  22. #endif
  23.  
  24. #define COMMAND_LIST case ID_EDIT_UNDO: cmd = EC_EDITUNDO; break; \
  25.                      case ID_EDIT_REDO: cmd = EC_EDITREDO; break; \
  26.                      case ID_EDIT_CLEAR: cmd = EC_EDITCLEAR; break; \
  27.                      case ID_EDIT_CLEAR_ALL: cmd = EC_TOOLSCLEARALL; break; \
  28.                      case ID_EDIT_CUT: cmd = EC_EDITCUT; break; \
  29.                      case ID_EDIT_COPY: cmd = EC_EDITCOPY; break; \
  30.                      case ID_EDIT_PASTE: cmd = EC_EDITPASTE; break; \
  31.                      case ID_EDIT_FIND: cmd = EC_SEARCHFIND; break; \
  32.                      case ID_EDIT_REPEAT: cmd = EC_SEARCHNEXT; break; \
  33.                      case ID_EDIT_REPLACE: cmd = EC_SEARCHREPLACE; break; \
  34.                      case ID_EDIT_SELECT_ALL: cmd = EC_EDITSELECTALL; break; \
  35.                      case EC_FILENEW: \
  36.                      case EC_FILEOPEN: \
  37.                      case EC_FILEREOPEN: \
  38.                      case EC_FILESAVE: \
  39.                      case EC_FILESAVEAS: \
  40.                      case EC_EDITUNDO: \
  41.                      case EC_EDITREDO: \
  42.                      case EC_EDITCUT: \
  43.                      case EC_EDITCOPY: \
  44.                      case EC_EDITPASTE: \
  45.                      case EC_EDITDUPLICATE: \
  46.                      case EC_EDITCLEAR: \
  47.                      case EC_SEARCHFIND: \
  48.                      case EC_SEARCHREPLACE: \
  49.                      case EC_SEARCHNEXT: \
  50.                      case EC_SEARCHLINE: \
  51.                      case EC_SEARCHBOOKMARK: \
  52.                      case EC_SEARCHSETBOOKMARK: \
  53.                      case EC_TOOLSCHANGEFONT: \
  54.                      case EC_TOOLSCLEARALL: \
  55.                      case EC_TOOLSCLEARUNDOBUFFER: \
  56.                      break; // Do nothing
  57.  
  58. /////////////////////////////////////////////////////////////////////////////
  59. // CLEdit
  60.  
  61. IMPLEMENT_DYNCREATE(CLEdit, CWnd)
  62.  
  63. CLEdit::CLEdit()
  64. {
  65.   LVer();
  66. }
  67.  
  68. WNDPROC* 
  69. CLEdit::GetSuperWndProcAddr()
  70. {
  71.    static WNDPROC NEAR pfnSuper;
  72.    return &pfnSuper;
  73. }
  74.  
  75. BOOL 
  76. CLEdit::Create(DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID)
  77. {
  78.    return CWnd::Create(LEDIT_CLASS, NULL, dwStyle, rect, pParentWnd, nID);
  79. }
  80.  
  81.  
  82. CLEdit::~CLEdit()
  83. {
  84.   DestroyWindow();
  85. }
  86.  
  87.  
  88. BEGIN_MESSAGE_MAP(CLEdit, CWnd)
  89.     //{{AFX_MSG_MAP(CLEdit)
  90.         // NOTE - the ClassWizard will add and remove mapping macros here.
  91.     //}}AFX_MSG_MAP
  92. END_MESSAGE_MAP()
  93.  
  94. HANDLE
  95. CLEdit::GetText()
  96. {
  97.   HANDLE Result = ::GlobalAlloc(GMEM_MOVEABLE,GetTextLength()+1);
  98.   if (Result)
  99.      {
  100.         char far* Buf = (char far*) ::GlobalLock(Result);
  101.         if (Buf)
  102.           {
  103.              if (! GetText(Buf))
  104.                 {
  105.                   ::GlobalUnlock(Result);
  106.                   ::GlobalFree(Result);
  107.                   Result = 0;
  108.                 }
  109.              else ::GlobalUnlock(Result);
  110.           }
  111.         else
  112.           {
  113.              ::GlobalFree(Result);
  114.              Result = 0;
  115.           }
  116.      };
  117.   return Result;
  118. }
  119.  
  120. void
  121. CLEdit::SetText(HANDLE hGlobal)
  122. {
  123.   char far* Buf = (char far*) ::GlobalLock(hGlobal);
  124.   if (Buf) SetText(Buf);
  125.   ::GlobalUnlock(hGlobal);
  126. }
  127.  
  128. HANDLE
  129. CLEdit::GetSelText()
  130. {
  131.   HANDLE Result = ::GlobalAlloc(GMEM_MOVEABLE,GetTextLength()+1);
  132.   if (Result)
  133.      {
  134.         char far* Buf = (char far*) ::GlobalLock(Result);
  135.         if (Buf)
  136.           {
  137.              if (! GetSelText(Buf))
  138.                 {
  139.                   ::GlobalUnlock(Result);
  140.                   ::GlobalFree(Result);
  141.                   Result = 0;
  142.                 }
  143.              else ::GlobalUnlock(Result);
  144.           }
  145.         else
  146.           {
  147.              ::GlobalFree(Result);
  148.              Result = 0;
  149.           }
  150.      };
  151.   return Result;
  152. }
  153.  
  154. void
  155. CLEdit::SetSelText(HANDLE hGlobal)
  156. {
  157.   char far* Buf = (char far*) ::GlobalLock(hGlobal);
  158.   if (Buf) SetSelText(Buf);
  159.   ::GlobalUnlock(hGlobal);
  160. }                          
  161.  
  162. void
  163. CLEdit::SetSyntax(char far* syntax, int flags)
  164. {
  165.   char far* Sx;
  166.   int W = 0;       
  167.   SYNTAX Syntax[256];
  168.   if (*syntax != 0)
  169.      {
  170.         for (Sx = syntax;(*Sx != 0) && (W < 254);Sx++)
  171.         switch (*Sx)
  172.           {
  173.              case '0':
  174.                 {
  175.                   Syntax[W].cFirst = 1;
  176.                   Syntax[W].cSecond = 1;
  177.                   W++;
  178.                   break;
  179.                 }
  180.              case '1':
  181.                 {
  182.                   if (*(Sx+1) == 0)
  183.                      break;
  184.                   Sx++;
  185.                   Syntax[W].cFirst = *Sx;
  186.                   Syntax[W].cSecond = 0;
  187.                   W++;
  188.                   break;
  189.                 }
  190.              case '2':
  191.                 {
  192.                   if (*(Sx+1) == 0)
  193.                      break;
  194.                   if (*(Sx+2) == 0)
  195.                      {
  196.                         Sx++;
  197.                         break;
  198.                      }
  199.                   Sx++;
  200.                   Syntax[W].cFirst = *Sx;
  201.                   Sx++;
  202.                   Syntax[W].cSecond = *Sx;
  203.                   W++;
  204.                   break;
  205.                 }
  206.           }
  207.      }
  208.   SetSyntax(Syntax,W,flags);
  209. }
  210.  
  211. void
  212. CLEdit::SetSelection(long StartLine,short int StartPosition, long EndLine,
  213.   short int EndPosition)
  214. {
  215.   LEDITPOSITION Pos;
  216.   Pos.StartLine = StartLine;
  217.   Pos.StartPosition = StartPosition;
  218.   Pos.EndLine = EndLine;
  219.   Pos.EndPosition = EndPosition;
  220.   SetSelection(Pos);
  221. }
  222.  
  223. BOOL
  224. CLEdit::IsSelection()
  225. {
  226.   LEDITPOSITION Pos;
  227.   GetSelection(Pos);
  228.   return (Pos.StartPosition != Pos.EndPosition) ||
  229.             (Pos.StartLine != Pos.EndLine);
  230. }
  231.  
  232. void
  233. CLEdit::SetScrollBars(BOOL horzScrollBar, BOOL vertScrollBar)
  234. {
  235.   SetHorzScrollBar(horzScrollBar);
  236.   SetVertScrollBar(vertScrollBar);
  237. }
  238.  
  239. void
  240. CLEdit::SetHorzScrollBar(BOOL horzScrollBar)
  241. {
  242.   (horzScrollBar) ?
  243.     SendMessage(EM_SETMETRICS,0,SendMessage(EM_GETMETRICS) | 0x10000L)
  244.    :SendMessage(EM_SETMETRICS,0,SendMessage(EM_GETMETRICS) & 0xFFFEFFFFL);
  245. }
  246.  
  247. void
  248. CLEdit::SetVertScrollBar(BOOL vertScrollBar)
  249. {
  250.   (vertScrollBar) ?
  251.     SendMessage(EM_SETMETRICS,0,SendMessage(EM_GETMETRICS) | 0x20000L)
  252.    :SendMessage(EM_SETMETRICS,0,SendMessage(EM_GETMETRICS) & 0xFFFDFFFFL);
  253. }
  254.  
  255. void
  256. CLEdit::SetExtraSpacing(short horzSpacing, short vertSpacing)
  257. {
  258.   SetHorzScrollBar(horzSpacing);
  259.   SetVertScrollBar(vertSpacing);
  260. }
  261.  
  262. void
  263. CLEdit::SetExtraHorzSpacing(short horzSpacing)
  264. {
  265.    SendMessage(EM_SETMETRICS,0,(SendMessage(EM_GETMETRICS)
  266.      & 0xFFFFFFF0L) | (horzSpacing & 0xF));
  267. }
  268.  
  269. void
  270. CLEdit::SetExtraVertSpacing(short vertSpacing)
  271. {
  272.    SendMessage(EM_SETMETRICS,0,(SendMessage(EM_GETMETRICS)
  273.      & 0xFFFFFF0FL) | ((vertSpacing >> 4) & 0xF));
  274. }
  275. /////////////////////////////////////////////////////////////////////////////
  276. // CLEditView
  277.  
  278. IMPLEMENT_DYNCREATE(CLEditView, CView)
  279.  
  280. CLEditView::CLEditView()
  281. {     
  282.    LVer();
  283.    m_clrBackColor = GetSysColor(COLOR_WINDOW);
  284.    m_clrForeColor = GetSysColor(COLOR_WINDOWTEXT);
  285.    m_clrBackColorSelected = GetSysColor(COLOR_HIGHLIGHT);
  286.    m_clrForeColorSelected = GetSysColor(COLOR_HIGHLIGHTTEXT);
  287.    m_bUseMemoryDC = FALSE;
  288. }
  289.  
  290. CLEditView::~CLEditView()
  291. {
  292.     ASSERT(m_hWnd == NULL);
  293. }
  294.  
  295. BEGIN_MESSAGE_MAP(CLEditView, CView)
  296.     //{{AFX_MSG_MAP(CLEditView)
  297.     ON_WM_CREATE()
  298.     ON_WM_CTLCOLOR()
  299.     ON_MESSAGE(EM_CTLCOLOR, OnEmCtlColor)
  300.     ON_MESSAGE(EM_CTLCOLOREX, OnEmCtlColorEx)
  301.     ON_MESSAGE(EM_DRAW, OnEmDraw)
  302.     ON_MESSAGE(EM_FINDBRACE, OnEmFindBrace)
  303.     ON_MESSAGE(EM_WORDCLICK, OnEmWordClick)
  304.     ON_WM_PAINT()
  305.     //}}AFX_MSG_MAP
  306.     // Standard Print commands (print only - not preview)
  307. END_MESSAGE_MAP()
  308.  
  309. const DWORD CLEditView::dwStyleDefault =
  310.     AFX_WS_DEFAULT_VIEW |
  311.     WS_HSCROLL | WS_VSCROLL |
  312.     ES_SMALLINDENT;
  313.     
  314. WNDPROC* 
  315. CLEditView::GetSuperWndProcAddr()
  316. {
  317.     static WNDPROC NEAR pfnSuper;
  318.     return &pfnSuper;
  319. }
  320.  
  321. /////////////////////////////////////////////////////////////////////////////
  322. // CLEditView message handlers
  323.  
  324. // class name for control creation
  325. static char BASED_CODE szClassName[] = LEDIT_CLASS;
  326.  
  327. int 
  328. CLEditView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  329. {
  330.     if (CView::OnCreate(lpCreateStruct) == -1)
  331.         return -1;
  332.     
  333.     SendMessage(EM_SETRUNTIMEFLAGS,EMP_16_AS32);
  334.     SendMessage(EM_EX_SETHANDLE,EC_DEFAULT_LEDIT_ID,(UINT)GetSafeHwnd());
  335.     return 0;
  336. }
  337.  
  338. HBRUSH 
  339. CLEditView::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor) 
  340. {
  341.     // TODO: Add your message handler code here and/or call default
  342.     pDC->SetBkColor(m_clrBackColor);
  343.     pDC->SetTextColor(m_clrForeColor);
  344.     return 0;
  345. }
  346.  
  347. LRESULT 
  348. CLEditView::OnEmCtlColor(WPARAM wp, LPARAM lp)
  349. {
  350.     CDC* pDC = CDC::FromHandle((HDC) wp);
  351.     pDC->SetBkColor(m_clrBackColorSelected);
  352.     pDC->SetTextColor(m_clrForeColorSelected);
  353.     return 0;
  354. }
  355.  
  356. LRESULT 
  357. CLEditView::OnEmDraw(WPARAM wp, LPARAM lp)
  358. {
  359.   HDC DC = (HDC) wp;
  360.   LRESULT LResult = 0;
  361.   HDC MemDC;
  362.   HBITMAP BitMap;
  363.   RECT Attr;
  364.  
  365.   GetClientRect(&Attr);
  366.  
  367.   // Involve bitmap if needed
  368.   if ( m_bUseMemoryDC )
  369.      {
  370.         MemDC = ::CreateCompatibleDC(DC);
  371.         if ( MemDC )
  372.           {
  373.              BitMap = ::CreateCompatibleBitmap(DC,Attr.right,Attr.bottom);
  374.              if ( BitMap )
  375.                 {
  376.                   // Set result to return
  377.                   LResult = (int) BitMap;
  378.  
  379.                   // Select the bitmap in MemDC and retrieve
  380.                   // the handle of previous bitmap
  381.                   BitMap = (HBITMAP) ::SelectObject(MemDC,BitMap);
  382.  
  383.                   // Bind all drawing to MemDC
  384.                   DC = MemDC;
  385.                 }
  386.              else
  387.                 {
  388.                   // We need not MemDC if we haven't got any bitmap
  389.                   ::DeleteDC(MemDC);
  390.                   MemDC = 0;
  391.                 }
  392.           }
  393.      }
  394.   else MemDC = 0;
  395.  
  396.   // Call User Function Draw(DC)
  397.   {
  398.     CDC* pDC = CDC::FromHandle(DC);
  399.     OnDrawBehind(pDC);
  400.   }
  401.  
  402.   // Delete memory DC if it exists
  403.   if ( MemDC )
  404.      {
  405.         SelectObject(MemDC,BitMap);
  406.         DeleteDC(MemDC);
  407.      }
  408.  
  409.   // Return value that was prepared
  410.   return LResult;
  411. }
  412.  
  413. LRESULT 
  414. CLEditView::OnEmCtlColorEx(WPARAM wp, LPARAM lp)
  415. {
  416.   WORDDESC far* pWD = (WORDDESC far*) lp;
  417.   CDC* pDC = CDC::FromHandle((HDC) wp);
  418.   OnControlHighlight(*pWD,pDC);
  419.   return 0;
  420. }
  421.  
  422. LRESULT 
  423. CLEditView::OnEmFindBrace(WPARAM wp, LPARAM lp)
  424. {
  425.   WORDDESC far* pWD = (WORDDESC far*) lp;
  426.   return (OnFindBrace(*pWD));
  427. }
  428.  
  429. LRESULT 
  430. CLEditView::OnEmWordClick(WPARAM wp, LPARAM lp)
  431. {
  432.   if (lp == 0)
  433.     return 0;
  434.   WORDDESC far* pWD = (WORDDESC far*) lp;
  435.   return (OnWordClick(*pWD));
  436. }
  437.       
  438. ////////////////////////////////////
  439. // Target for all the messages
  440. //            
  441. #ifdef WIN32
  442. #define NOTIFY_CODE HIWORD(wParam)         
  443. #else
  444. #define NOTIFY_CODE HIWORD(lParam)
  445. #endif                 
  446.                  
  447. LRESULT 
  448. CLEditView::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
  449. {                                    
  450. if (message == WM_COMMAND)             
  451. {                
  452.   unsigned short cmd = LOWORD(wParam);
  453.   switch (cmd)
  454.   {           
  455.     default:
  456.       return CView::WindowProc(message, wParam, lParam);
  457.     case EC_DEFAULT_LEDIT_ID:
  458.       switch (NOTIFY_CODE)
  459.       {
  460.         case EN_CHANGE: 
  461.           {                 
  462.             CDocument* Doc = GetDocument();
  463.             if (Doc)
  464.               Doc->SetModifiedFlag(GetLEditCtrl().IsModified(15));
  465.             OnChange();
  466.             break;
  467.           }
  468.         case EN_HSCROLL:
  469.           OnHorzScroll();
  470.           break;
  471.         case EN_VSCROLL:
  472.           OnVertScroll(); 
  473.           break;
  474.         case EN_NEWFILE:
  475.           OnNewFile();
  476.           break;
  477.         case EN_NEWFONT:
  478.           OnNewFont();
  479.           break;
  480.         case EN_INSERTMODE:
  481.         case EN_OVERWRITEMODE:
  482.           OnChangeMode();
  483.           break;
  484.         case EN_GOINGTOCLOSE:
  485.           return OnGoingToClose();
  486.         case EN_STOREFILE:
  487.           return OnAskIfStoreFile();
  488.         case EN_FILEERROR:
  489.           return OnFileError();
  490.         case EN_CLIPBOARD:
  491.           return OnClipboardError();
  492.         case EN_MAXTEXT:
  493.           return OnMaxText();
  494.         case EN_ERRSPACE:
  495.           return OnSpaceError();
  496.       }
  497.       return CMD_DOITYOURSELF;
  498.     COMMAND_LIST // Translates cmd as needed. Catch up all the
  499.                  // command handled. Others go to default.
  500.   }          
  501.   return DefWindowProc(WM_COMMAND,cmd,0);
  502. }
  503. else
  504.   return CView::WindowProc(message, wParam, lParam);
  505. }
  506.  
  507. BOOL CLEditView::OnCmdMsg(UINT nID, int nCode, void* pExtra,
  508.         AFX_CMDHANDLERINFO* pHandlerInfo)
  509. {                       
  510.   if (nCode == CN_UPDATE_COMMAND_UI)
  511.   {
  512.     unsigned short cmd = nID;
  513.     switch (cmd)
  514.     {  
  515.        default:
  516.          return CView::OnCmdMsg(nID,nCode,pExtra,pHandlerInfo); 
  517.        COMMAND_LIST // Translates cmd as needed. Catch up all the
  518.                  // command handled. Others go to default.
  519.     }
  520.     CCmdUI* CmdUI = (CCmdUI*) pExtra;
  521.     CmdUI->Enable(SendMessage(EM_CANEXECUTECOMMAND,cmd) != 0);
  522.     return TRUE;
  523.   
  524.   }
  525.   else if (nCode == CN_COMMAND)
  526.   {
  527.     unsigned short cmd = nID;
  528.     switch (cmd)
  529.     {
  530.        default:
  531.          return CView::OnCmdMsg(nID,nCode,pExtra,pHandlerInfo); 
  532.        COMMAND_LIST // Translates cmd as needed. Catch up all the
  533.                  // command handled. Others go to default.
  534.     }
  535.     SendMessage(WM_COMMAND,cmd);
  536.     return TRUE;
  537.   }
  538.   else return CView::OnCmdMsg(nID,nCode,pExtra,pHandlerInfo);
  539. }
  540.  
  541.  
  542. BOOL 
  543. CLEditView::PreCreateWindow(CREATESTRUCT& cs)
  544. {
  545.     ASSERT(cs.lpszClass == NULL);
  546.     cs.lpszClass = szClassName;
  547.  
  548.     // map default CView style to default CEditView style
  549.     if (cs.style == AFX_WS_DEFAULT_VIEW)
  550.         cs.style = dwStyleDefault;
  551.  
  552.     return TRUE;
  553. }
  554.  
  555. /////////////////////////////////////////////////////////////////////////////
  556. // CLEditView document like functions
  557.  
  558. void CLEditView::DeleteContents()
  559. {
  560.     ASSERT_VALID(this);
  561.     ASSERT(m_hWnd != NULL);
  562.     GetLEditCtrl().Clear();
  563.     GetLEditCtrl().ClearModify(15);
  564.     CDocument* Doc = GetDocument();
  565.     if (Doc)
  566.       Doc->SetModifiedFlag(FALSE);
  567.     ASSERT_VALID(this);
  568. }
  569.  
  570. void CLEditView::Serialize(CArchive& ar)
  571. // Read and write CLEditView object to archive, with length prefix.
  572. {
  573.     ASSERT_VALID(this);
  574.     ASSERT(m_hWnd != NULL);
  575.     if (ar.IsStoring())
  576.     {
  577.         DWORD dwLen = GetLEditCtrl().GetTextLength();
  578.         ar << dwLen;
  579.         WriteToArchive(ar);
  580.     }
  581.     else
  582.     {
  583.         DWORD dwLen;
  584.         ar >> dwLen;
  585.         ReadFromArchive(ar, dwLen);
  586.     }
  587.     ASSERT_VALID(this);
  588. }
  589.  
  590. void CLEditView::SerializeRaw(CArchive& ar)
  591.         // Read/Write object as stand-alone file.
  592. {
  593.         ASSERT_VALID(this);
  594.         if (ar.IsStoring())
  595.         {
  596.                 WriteToArchive(ar);
  597.         }
  598.         else
  599.         {
  600.                 CFile* pFile = ar.GetFile();
  601.                 ASSERT(pFile->GetPosition() == 0);
  602.                 DWORD dwFileSize = pFile->GetLength();
  603.                 ReadFromArchive(ar, dwFileSize);
  604.         }
  605.         ASSERT_VALID(this);
  606. }
  607.  
  608.  
  609. void CLEditView::ReadFromArchive(CArchive& ar, DWORD dwLen)
  610.     // Read certain amount of text from the file, assume at least dwLen
  611.     // bytes are in the file.
  612. {
  613.     ASSERT_VALID(this);
  614.     DWORD pos = 0;
  615.     HANDLE H = ::GlobalAlloc(GMEM_MOVEABLE, dwLen+1);
  616.     if (H == 0)
  617.         return;
  618.     char HUGE_PTR* Pt = (char HUGE_PTR*) ::GlobalLock(H);
  619.     if (Pt == NULL)
  620.       {
  621.          ::GlobalFree(H);
  622.          return;
  623.       }
  624.       
  625. #define PART 0x4000  
  626.  
  627.     while (pos != dwLen)
  628.      {
  629.         DWORD rest = 0x10000L - FP_OFF(Pt);
  630.         rest = ((dwLen-pos) > rest) ? rest : (dwLen-pos);
  631.         int toWrite = (rest > PART) ? PART : LOWORD(rest);
  632.         int read = ar.Read((char far*) Pt, toWrite);
  633.         if (read != toWrite)
  634.           {
  635.              ::GlobalUnlock(H);
  636.              ::GlobalFree(H);
  637.              return;
  638.           }
  639.         Pt += toWrite;
  640.         pos += toWrite;
  641.      }           
  642.     *Pt = 0;
  643.     GetLEditCtrl().SetText(H);
  644.     GetLEditCtrl().EmptyUndoBuffer();
  645.     GetLEditCtrl().ClearModify(15);
  646.     ::GlobalUnlock(H);
  647.     ::GlobalFree(H);
  648.     ASSERT_VALID(this);
  649. }
  650.  
  651. void CLEditView::WriteToArchive(CArchive& ar)
  652.     // Write just the text to an archive, no length prefix.
  653. {
  654.     ASSERT_VALID(this);         
  655.     HANDLE H = GetLEditCtrl().GetText();
  656.     if (H == 0)
  657.         return;
  658.     char HUGE_PTR* Pt = (char HUGE_PTR*) ::GlobalLock(H);
  659.     if (Pt == NULL)
  660.         return;     
  661.         
  662.     TRY {
  663.     while (*Pt != 0)
  664.       {
  665.          char HUGE_PTR* PtX = Pt;
  666.          int toWrite = 0;
  667.          while ((*PtX != 0) && (toWrite <= PART) && ((FP_SEG(PtX) == FP_SEG(Pt))))
  668.            {
  669.              PtX++;
  670.              toWrite++;
  671.            }
  672.          ar.Write((char far*)Pt, toWrite);
  673.          Pt = PtX;
  674.      }
  675.     } // TRY
  676.     CATCH_ALL(e)
  677.     {
  678.         ::GlobalUnlock(H);
  679.         ::GlobalFree(H);
  680.         THROW_LAST();
  681.         ASSERT(FALSE);
  682.     }
  683.     END_CATCH_ALL    
  684.     ::GlobalUnlock(H);
  685.     ::GlobalFree(H);
  686.     GetLEditCtrl().ClearModify(15);
  687.     ASSERT_VALID(this);
  688. }
  689.  
  690. /////////////////////////////////////////////////////////////////////////////
  691. // CLEditView drawing
  692.  
  693. void CLEditView::OnPaint()
  694. {
  695.     Default();
  696. }
  697.  
  698. void CLEditView::OnDraw(CDC*)
  699. {
  700. }
  701.  
  702. /////////////////////////////////////////////////////////////////////////////
  703. // CLEditView "events" with implementations
  704.  
  705. void CLEditView::OnDrawBehind(CDC*)
  706. {
  707. }                     
  708.  
  709. void CLEditView::OnControlHighlight(WORDDESC& WD, CDC* pDC)
  710. {
  711. }
  712.  
  713. short CLEditView::OnFindBrace(WORDDESC& WD)
  714. { 
  715.   return 0;
  716. }
  717.  
  718. short CLEditView::OnWordClick(WORDDESC& WD)
  719. {          
  720.   return 0;
  721. }
  722.               
  723. void CLEditView::OnChange()
  724. {
  725. }
  726.  
  727. void CLEditView::OnHorzScroll()
  728. {
  729. }
  730.  
  731. void CLEditView::OnVertScroll()
  732. {
  733. }
  734.  
  735. void CLEditView::OnNewFile()
  736. {
  737. }
  738.  
  739. void CLEditView::OnNewFont()
  740. {
  741. }
  742.  
  743. void CLEditView::OnChangeMode()
  744. {
  745. }
  746.  
  747. short CLEditView::OnGoingToClose()
  748. {
  749.   return CMD_DOITYOURSELF;
  750. }
  751.    
  752. short CLEditView::OnAskIfStoreFile()
  753. {
  754.   return CMD_DOITYOURSELF;
  755. }
  756.  
  757. short CLEditView::OnFileError()
  758. {
  759.   return CMD_DOITYOURSELF; 
  760. }
  761.  
  762. short CLEditView::OnClipboardError()
  763. {
  764.   return CMD_DOITYOURSELF;
  765. }
  766.  
  767. short CLEditView::OnMaxText()
  768. {
  769.   return CMD_DOITYOURSELF;
  770. }
  771.  
  772. short CLEditView::OnSpaceError()
  773. {
  774.   return CMD_DOITYOURSELF;
  775. }
  776.